During the creation of software applications, coding errors are not uncommon. Finding these errors, or debugging, can be a tedious process. For example, it may be possible that the same error scenario occurs at various points in the software.
As an example, assume that the software is designed for a network device. One possible error is that a remote node, to which the present device is communicating or attempting to communicate with, stops responding or becomes unavailable. This may occur at various points in the software. For example, this may occur when the present device is transmitting information to that remote node and the remote node fails to acknowledge that information. Alternatively, it may occur when the remote node is transmitting information to the present node and then simply stops. Of course, there are other scenarios when may cause the present device to determine that the remote device is no longer available.
This can happen with other error scenarios as well. For example, the software may be configured to expect a response (such as from a remote node or another software module) within a predetermined period of time. If that response is not received within that period of time, an error is generated. This error may indicate that a time-out occurred. Again, an error reporting a time-out may be associated with various different actions and procedures.
Consequently, the use of simple error codes may make it difficult to efficiently debug the software, since the error code may fail to provide enough information as to where in the software the error actually occurred. As described above, a time-out may occur at various points in the software. Returning an error indicating that a time-out occurred may not pin point the exact location in the software where the error occurred.
Thus, one technique that is used to debug code is to “step” through the code. This involves having the code execute one instruction at a time so that the software developer can observe what is occurring. However, in the case of certain errors, such as the time-out scenario presented above, the error may not occur in this debug mode. Further, even if the error does occur, the time expended to identify where the error occurred may be unacceptably high.
Therefore, it would be beneficial if there were system and method for providing more comprehensive error information whenever the software encountered an error. This comprehensive error information would allow the developer to more quickly identify and rectify the problem.